expr_has_explicit_ty misses some other coercion sites such as

fn main() {
    let x: &[u8; 4] = b"1234";
    f(match Some(()) {
        Some(_) => Some(Box::new(x)),
        None => None,
    });
}

fn f(_: Option<Box<&[u8]>>) {}

I think an easier way to rule out unrelated coercion false negatives would be to recursively check the coercion propagating subexpressions (see the second list in the above link) rather than every subexpression for adjustments

sorry, shame to admit that I'm currently stuck on this 🤦‍♂️.

I'm pretty sure I misunderstand the concept, and I couldn't get it to work, especially for this specific test case:

//~v ERROR: manual implementation of `Option::map`
let _ = match Some(0) {
    Some(_) => Some(match f() {
        Ok(res) => Ok(Box::new(res)),
        _ => Err(()),
    }),
    None => None,
};

Do you mind provid some more guidence? 😅

Looking into it more I was incorrect earlier, I had assumed that the point at which the adjustment happens wouldn't cross "past" a coercion site, i.e. in

let x: &[u8; 4] = b"1234";
f(match Some(()) {
    Some(_) => Some(Box::new(x)),
               ~~~~~~~~~~~~~~~~~ I thought the adjustment happened here
                             ~ but it happens here
    None => None,
});

I think checking for coercion propagating expressions and expressions that are coercion sites may still work though, roughly

fn is_coerced(expr) -> bool {
    if expr has adjustments {
        return true;
    }

    match expr.kind {
        // regular coercion sites
        Call | MethodCall => args.any(is_coerced),
        Struct | Enum | Union => fields.any(is_coerced),
        // propagating
        Array => elements.any(is_coerced),
        Repeat => is_coerced(repeated),
        Tuple => fields.any(is_coerced),
        Block => is_coerced(block.expr),
        If => is_coerced(then) || is_coerced(r#else),
        Match => arms.any(is_coerced),
    }
}

The key difference to the current implementation is the direction, we're looking at children rather than parents. In your example the adjustment that we don't care about happens at f, but we avoid a false negative because we never check that expression

let _ = match Some(0) {
    Some(_) => Some(match f() {
                          ~ adjustment here
        Ok(res) => Ok(Box::new(res)),
        _ => Err(()),
    }),
    None => None,
};

There will be false positives though:

fn g(b: &[u8]) -> Box<&[u8]> {
    Box::new(b)
}

let x: &[u8; 4] = b"1234";

// ok
let _: Option<Box<&[u8]>> = match Some(0) {
    Some(_) => Some(g(x)),
    None => None,
};

// also ok
let _: Option<Box<&[u8]>> = Some(0).map(|_| g(x));

You might be able to eliminate these by checking that the type of the relevant arg/field/etc is concrete, but also accepting those FNs is perfectly fine to me

There is an interesting FN case in manual_map_option.rs:

match Some(&String::new()) {
    Some(x) => Some(str::len(x)),
    None => None,
};

the &String was coerced to &str but it shouldn't matter right? I don't know if checking the type for concrete concreteness is possible, thus I'm still finding a way to eliminate this 😸

From a Ty I think it would be something like .has_type_flags(TypeFlags::HAS_TY_PARAM)

You can use expr_sig on the callee/receiver as like a tcx.fn_sig that works for closures/etc too

If the output of the function doesn't have a ty param then it should(?) be fine to return false

For individual args you could zip the inputs with the args, only checking the arg if it HAS_TY_PARAM

That works perfectly! Thank you so much 👍